const dayjs = require('dayjs');
/**
 * 研发项目资源管理模块
 * 负责处理研发项目的资源上传、下载、预览等功能
 */

// 引入基础文件管理模块
const BaseFileManager = require('./base_file_manager');

// 引入辅助工具
const pageHelper = require('./helpers/page_helper.js');

/**
 * 资源管理器类
 * 用于处理研发项目中的资源管理
 */
class ResourceManager extends BaseFileManager {
  /**
   * 构造函数
   * @param {Object} page - 页面实例
   * @param {Object} options - 配置选项
   */
  constructor(page, options = {}) {
    super(page, options);
  }

  /**
   * 初始化资源文件夹结构
   * @returns {Array} 资源文件夹结构
   */
  initResourceFolders() {
    return [
      { id: 'package', name: '包装指引', files: [] },
      { id: 'process', name: '加工指引', files: [] },
      { id: 'material', name: '物料变更通知', files: [] },
      { id: 'bom', name: 'BOM', files: [] },
      { id: 'report', name: '认证报告', files: [] },
      { id: 'test_report', name: '测试报告', files: [] },
      { id: 'test_guide', name: '测试指引', files: [] },
      { id: 'spec', name: '产品规格书', files: [] },
      { id: 'code', name: '代码', files: [] },
      { id: 'firmware', name: '烧录文件', files: [] },
      { id: 'structure', name: '结构', files: [] },
      { id: 'customer', name: '客户文件', files: [] },
      { id: 'component', name: '元器件 规格书', files: [] },
      { id: 'schematic', name: '原理图', files: [] },
      { id: 'pcb', name: 'PCB', files: [] },
      { id: 'manual', name: '作业指导书', files: [], active: true }
    ];
  }

  /**
   * 获取资源版本列表
   * @param {string} projectId - 项目ID
   * @param {boolean} useCache - 是否使用缓存
   * @returns {Promise<Array>} 资源版本列表
   */
  async getResourceVersionList(projectId, useCache = true) {
    // 检查缓存
    const cacheKey = `resource_versions_${projectId}`;
    const cachedData = useCache ? this.getCache(cacheKey) : null;
    if (cachedData) {
      return cachedData;
    }

    try {
      // 请求服务器数据
      const params = {
        projectId: projectId
      };
      
      const result = await this.callApiWithLoading('research/get_resource_versions', params, '获取资源列表');
      
      // 格式化数据
      if (result && Array.isArray(result)) {
        result.forEach(item => {
          item.RESOURCE_ADD_TIME_DISPLAY = this._formatDateTime(item.RESOURCE_ADD_TIME);
          item.RESOURCE_SIZE_DISPLAY = this.formatFileSize(item.RESOURCE_SIZE || 0);
        });
      }
      
      // 更新缓存
      this.setCache(cacheKey, result || []);
      
      return result || [];
    } catch (error) {
      console.error('获取资源版本列表失败', error);
      throw error;
    }
  }

  /**
   * 上传资源
   * @param {Object} resource - 资源信息
   * @returns {Promise<Object>} 上传结果
   */
  async uploadResource(resource) {
    if (!resource) return null;
    
    try {
      // 扩展额外的资源信息
      const extraData = {
        folderId: resource.folderId || 'other',
        version: resource.version || '1.0',
        desc: resource.desc || ''
      };
      
      // 使用基类的上传文件方法
      return await this.uploadFile(resource, 'resource', extraData, 'research/upload_resource');
    } catch (error) {
      console.error('上传资源失败', error);
      throw error;
    }
  }

  /**
   * 预览资源
   * @param {Object} resource - 资源对象
   * @returns {Promise<void>}
   */
  async viewResource(resource) {
    if (!resource || !resource.RESOURCE_FILE_ID) {
      pageHelper.showError('资源不存在');
      return;
    }

    // 标准化资源对象
    const file = {
      fileId: resource.RESOURCE_FILE_ID,
      name: resource.RESOURCE_NAME
    };

    // 使用基类的预览文件方法
    await this.viewFile(file);
  }

  /**
   * 下载资源
   * @param {Object} resource - 资源对象
   * @returns {Promise<void>}
   */
  async downloadResource(resource) {
    if (!resource || !resource.RESOURCE_FILE_ID) {
      pageHelper.showError('资源不存在');
      return;
    }

    // 标准化资源对象
    const file = {
      fileId: resource.RESOURCE_FILE_ID,
      name: resource.RESOURCE_NAME
    };

    // 使用基类的下载文件方法
    await this.downloadFile(file);
  }

  /**
   * 批量下载资源
   * @param {Array} resources - 资源列表
   * @returns {Promise<void>}
   */
  async batchDownloadResources(resources) {
    // 使用基类的批量下载方法
    await this.batchDownloadFiles(resources, 'RESOURCE_FILE_ID', 'RESOURCE_NAME');
  }

  /**
   * 删除资源
   * @param {string} resourceId - 资源ID
   * @param {string} projectId - 项目ID
   * @returns {Promise<boolean>} 是否删除成功
   */
  async deleteResource(resourceId, projectId) {
    const params = { resourceId };
    
    // 使用基类的删除文件方法
    return await this.deleteFile(resourceId, projectId, 'research/delete_resource', params);
  }

  /**
   * 获取最新版本的资源
   * @param {Array} resourceVersions - 资源版本列表
   * @returns {Array} 最新版本的资源列表
   */
  getLatestResourceVersions(resourceVersions) {
    if (!resourceVersions || !Array.isArray(resourceVersions) || resourceVersions.length === 0) {
      return [];
    }
    
    // 按资源名称分组并保留最高版本
    const resourceMap = new Map();
    
    resourceVersions.forEach(resource => {
      const key = resource.RESOURCE_NAME + '_' + resource.RESOURCE_FOLDER_ID;
      
      if (!resourceMap.has(key) || 
          parseFloat(resource.RESOURCE_VERSION) > parseFloat(resourceMap.get(key).RESOURCE_VERSION)) {
        resourceMap.set(key, resource);
      }
    });
    
    return Array.from(resourceMap.values());
  }

  /**
   * 处理资源数据，按文件夹分类
   * @param {Array} folders - 文件夹列表
   * @param {Array} resources - 资源列表
   * @returns {Array} 处理后的文件夹列表（包含资源）
   */
  processResourceData(folders, resources) {
    if (!folders || !Array.isArray(folders) || !resources || !Array.isArray(resources)) {
      return folders || [];
    }
    
    // 复制文件夹列表
    const processedFolders = JSON.parse(JSON.stringify(folders));
    
    // 按文件夹ID分组
    const folderMap = new Map();
    processedFolders.forEach(folder => {
      folderMap.set(folder.id, folder);
    });
    
    // 将资源添加到对应文件夹
    resources.forEach(resource => {
      const folderId = resource.RESOURCE_FOLDER_ID || 'other';
      
      if (folderMap.has(folderId)) {
        folderMap.get(folderId).files.push(resource);
      } else {
        // 如果没有对应文件夹，添加到其他文件夹
        if (folderMap.has('other')) {
          folderMap.get('other').files.push(resource);
        } else {
          // 如果没有其他文件夹，创建一个
          const otherFolder = { id: 'other', name: '其他', files: [resource] };
          processedFolders.push(otherFolder);
          folderMap.set('other', otherFolder);
        }
      }
    });
    
    return processedFolders;
  }

  /**
   * 格式化日期时间
   * @private
   * @param {string|Date} datetime - 日期时间
   * @returns {string} 格式化后的日期时间
   */
  _formatDateTime(datetime) {
    if (!datetime) return '';
    
    try {
      // 使用Day.js处理日期
      const date = dayjs(datetime);
      
      // 直接使用Day.js的format方法格式化
      return date.format('YYYY-MM-DD HH:mm:ss');
    } catch (error) {
      console.error('格式化日期时间失败', error);
      return datetime.toString();
    }
  }

  /**
   * 调用API并显示加载中状态
   * @private
   * @param {string} api - API路径
   * @param {Object} params - 请求参数
   * @param {string} loadingText - 加载提示文本
   * @returns {Promise<*>} API响应结果
   */
  async callApiWithLoading(api, params, loadingText) {
    const cloudHelper = require('./helpers/cloud_helper.js');
    const pageHelper = require('./helpers/page_helper.js');
    
    try {
      pageHelper.showLoading(loadingText);
      const result = await cloudHelper.callCloudData(api, params);
      pageHelper.hideLoading();
      return result;
    } catch (error) {
      pageHelper.hideLoading();
      throw error;
    }
  }
}

module.exports = ResourceManager; 